package day05_Function;
/*
例如：定义一个方法，实现两个数相加
数的类型不确定，可能是：byte、short、int、long、double
那么就需要定义五个方法针对不同的数据类型
还得记住5个方法的名字
特别麻烦

方法的重载：方法名字相同，参数列表不同
重载的好处：只需要记住一个函数名，就可以对 不同参数列表的数组 进行处理

方法重载到底与什么条件有关呢（什么情况下可以构成重载呢）？
1、参数的类型不一样
2、参数的长度不一样
3、对于有多个”不同类型“的参数，只要顺序不一样，也可以实现重载
方法重载跟什么无关呢？
1、参数的名字无关
2、跟方法的返回值类型无关

调用：
方法名(参数);
打印调用
赋值调用：需要根据方法的返回值类型判断到底用什么类型的变量接收
直接调用
 */
public class Demo08_方法重载 {
        public static void main(String[] args) {
            // 两个byte的数相加
            byte a = 10;
            byte b = 20;
            System.out.println(sum(a, b));// byte 30
            System.out.println(sum((short) a, (short) b));// short 30
            int num1 = sum(10, 30); // 调用int类型的加法
            sum(10, 30, 40); // 调用3个int类型的加法
            sum(10, 1.0);// 调用int double类型的加法
            sum(1.0, 11);// 调用double int类型的加法
            long num2 = sum(2L, 3L);// 调用long类型的加法
            double num3 = sum(1.0, 1.0);// 调用double类型的加法


        }

        // 两个byte类型的数相加
        public static byte sum(byte a, byte b) {
            System.out.println("调用了byte类型的加法");
            byte c = (byte) (a + b);
            return c;
        }
        // 重载跟参数名无关
        // 两个byte类型的数相加
        //    public static byte sum(byte x, byte y) {
        //        byte c = (byte) (x + y);
        //        return c;
        //    }

        // 两个short类型的数相加
        public static short sum(short a, short b) {
            System.out.println("调用了short类型的加法");
            short c = (short) (a + b);
            return c;
        }

        // 1个int类型的数与1个double类型的数相加
        public static int sum(int a, double b) {
            System.out.println("调用了int，double类型的加法");
            int c = (int) (a + b);
            return c;
        }

        // 方法重载跟返回值类型无关
//        public static double sum(int a, double b) {
//            double c = a + b;
//            return c;
//        }

        // 当有多个类型不一样的参数时，参数的顺序不同，也可以实现重载
        // 1个double类型的数与1个int类型的数相加
        public static int sum(double a, int b) {
            System.out.println("调用了double，int类型的加法");
            int c = (int) (a + b);
            return c;
        }

        // 两个int类型的数相加
        public static int sum(int a, int b) {
            System.out.println("调用了int类型的加法");
            int c = a + b;
            return c;
        }

        // 对于相同类型的多个参数，调换位置，不构成重载
        //    public static int sum(int b, int a) {
        //        int c = a + b;
        //        return c;
        //    }

        // 参数的个数不一样 也可以实现方法的重载
        // 三个int类型的数相加
        public static int sum(int a, int b, int c) {
            System.out.println("调用了3个int类型数的加法");
            int d = a + b + c;
            return d;
        }

        // 两个long类型的数相加
        public static long sum(long a, long b) {
            System.out.println("调用了long类型数的加法");
            long c = (long) a + b;
            return c;
        }

        // 两个double类型的数相加
        public static double sum(double a, double b) {
            System.out.println("调用了double类型数的加法");
            double c = (double) a + b;
            return c;
        }
    }
